#include "notepad.h"

const std::u8string Notepad::ConfigComment::type(Lang lang, TunnelType type)
{
    switch (lang)
    {
    case Lang::ru: {
        static const std::u8string ru {u8"# Тип туннеля:\n"};
        return ru + tunnelTypeDescription(lang, type);
    }
    default: {
        static const std::u8string en {u8"# Tunnel type. You have selected\n"};
        return en + tunnelTypeDescription(lang, type);
    }
    }
}

const char8_t *Notepad::ConfigComment::clientAddress(Lang lang)
{
    switch (lang)
    {
    case Lang::ru: {
        static const char8_t* ru {u8"# Локальный адрес, на котором будет доступен туннель\n"
                                    "# Например, 127.0.0.1\n"};
        return ru;
    }
    default: {
        static const char8_t* en {u8"# Local address where the tunnel will be accessed\n"
                                    "# For example, 127.0.0.1\n"};
        return en;
    }
    }
}

const char8_t *Notepad::ConfigComment::clientPort(Lang lang)
{
    switch (lang)
    {
    case Lang::ru: {
        static const char8_t* ru {u8"# Локальный порт, на котором будет доступен туннель\n"
                                    "# Например, 8080\n"};
        return ru;
    }
    default: {
        static const char8_t* en {u8"# Local port where the tunnel will be accessed\n"
                                    "# For example, 8080\n"};
        return en;
    }
    }
}

const char8_t *Notepad::ConfigComment::clientDestination(Lang lang)
{
    switch (lang)
    {
    case Lang::ru: {
        static const char8_t* ru {u8"# I2P-адрес сервера (*.b32.i2p)\n"};
        return ru;
    }
    default: {
        static const char8_t* en {u8"# I2P server address (*.b32.i2p)\n"};
        return en;
    }
    }
}

const char8_t *Notepad::ConfigComment::clientDestinationPort(Lang lang)
{
    switch (lang)
    {
    case Lang::ru: {
        static const char8_t* ru {u8"# Порт сервера в сети I2P\n"
                                    "# Можно не указывать, если по адресу доступен только один сервис\n"};
        return ru;
    }
    default: {
        static const char8_t* en {u8"# Server port on the I2P network\n"
                                    "# Can be omitted if only one service is available at the address\n"};
        return en;
    }
    }
}

const char8_t *Notepad::ConfigComment::clientKeepAlive(Lang lang)
{
    switch (lang)
    {
    case Lang::ru: {
        static const char8_t* ru {u8"# Интервал между отправками пингов на сервер для поддержания соединения\n"
                                    "# Для отключения используется значение 0 (значение по умолчанию)\n"};
        return ru;
    }
    default: {
        static const char8_t* en {u8"# Interval between sending pings to the server to maintain connection\n"
                                    "# To disable, the value 0 is used (default)\n"};
        return en;
    }
    }
}

const char8_t *Notepad::ConfigComment::serverAddress(Lang lang)
{
    switch (lang)
    {
    case Lang::ru: {
        static const char8_t* ru {u8"# Адрес локального интерфейса, который будет использован\n"
                                    "# для доступа к сервису (например, 192.168.0.2 или 127.0.0.1)\n"};
        return ru;
    }
    default: {
        static const char8_t* en {u8"# The address of the local interface to be used\n"
                                    "# to access the service (for example, 192.168.0.2 or 127.0.0.1)\n"};
        return en;
    }
    }
}

const char8_t *Notepad::ConfigComment::serverHost(Lang lang)
{
    switch (lang)
    {
    case Lang::ru: {
        static const char8_t* ru {u8"# Адрес сервиса, который будет доступен в сети I2P\n"
                                    "# Например, 192.168.0.3 или 127.0.0.1\n"};
        return ru;
    }
    default: {
        static const char8_t* en {u8"# The address of the service that will be available on the I2P\n"
                                    "# For example, 192.168.0.3 or 127.0.0.1\n"};
        return en;
    }
    }
}

const char8_t *Notepad::ConfigComment::serverPort(Lang lang)
{
    switch (lang)
    {
    case Lang::ru: {
        static const char8_t* ru {u8"# Порт сервиса, по которому он доступен в обычной сети\n"};
        return ru;
    }
    default: {
        static const char8_t* en {u8"# The service port on which it is accessible on the regular network\n"};
        return en;
    }
    }
}

const char8_t *Notepad::ConfigComment::serverInport(Lang lang)
{
    switch (lang)
    {
    case Lang::ru: {
        static const char8_t* ru {u8"# Порт, по которому сервис будет доступен в сети I2P\n"};
        return ru;
    }
    default: {
        static const char8_t* en {u8"# The port on which the service will be available on the I2P\n"};
        return en;
    }
    }
}

const char8_t *Notepad::ConfigComment::serverBlinded(Lang lang)
{
    switch (lang)
    {
    case Lang::ru: {
        static const char8_t* ru {u8"# Параметры для зашифрованного лизсета (b33 aka bb32).\n"
                                    "# Используется для дополнительной приватности сервера,"
                                    "# делая невозможным пассивное обнаружение сервиса через мониторинг флудфилов\n"
                                    "# Подробнее: https://habr.com/ru/articles/555604/\n"};
        return ru;
    }
    default: {
        static const char8_t* en {u8"# Parameters for encrypted leaseset (b33 aka bb32).\n"
                                    "# Used for additional server privacy,\n"
                                    "# making it impossible to passively detect the service through monitoring floodfilles\n"
                                    "# Read more (russian): https://habr.com/ru/articles/555604/\n"};
        return en;
    }
    }
}

const char8_t *Notepad::ConfigComment::inbound(Lang lang)
{
    switch (lang)
    {
    case Lang::ru: {
        static const char8_t* ru {u8"# Это конфиг туннеля, который является логической сущностью, обеспечивающей\n"
                                    "# соединение через сеть I2P. Фактически туннель состоит из нескольких туннелей,\n"
                                    "# которые называются нитями.\n"
                                    "# Параметры входящих нитей:\n"};
        return ru;
    }
    default: {
        static const char8_t* en {u8"# This is a tunnel config, which is a logical term that enables communication.\n"
                                    "# In fact, a tunnel consists of several tunnels, which are called strands.\n"
                                    "# Parameters of inbound strands:\n"};
        return en;
    }
    }
}

const char8_t *Notepad::ConfigComment::outbound(Lang lang)
{
    switch (lang)
    {
    case Lang::ru: {
        static const char8_t* ru {u8"# Параметры исходящих нитей:\n"};
        return ru;
    }
    default: {
        static const char8_t* en {u8"# Parameters of outbound strands:\n"};
        return en;
    }
    }
}

const char8_t *Notepad::ConfigComment::length(Lang lang)
{
    switch (lang)
    {
    case Lang::ru: {
        static const char8_t* ru {u8"# - Количество транзитных узлов (длина)\n"};
        return ru;
    }
    default: {
        static const char8_t* en {u8"# - Number of transit nodes (length)\n"};
        return en;
    }
    }
}

const char8_t *Notepad::ConfigComment::quantity(Lang lang)
{
    switch (lang)
    {
    case Lang::ru: {
        static const char8_t* ru {u8"# - Количество нитей\n"};
        return ru;
    }
    default: {
        static const char8_t* en {u8"# - Strands count\n"};
        return en;
    }
    }
}

const char8_t *Notepad::ConfigComment::variance(Lang lang)
{
    switch (lang)
    {
    case Lang::ru: {
        static const char8_t* ru {u8"# - Число, на которое будет меняться длина случайных нитей (от -3 до 3)\n"};
        return ru;
    }
    default: {
        static const char8_t* en {u8"# - The number by which the length of random strands will be changed (from -3 to 3)\n"};
        return en;
    }
    }
}

const char8_t *Notepad::ConfigComment::keysTransient(Lang lang)
{
    switch (lang)
    {
    case Lang::ru: {
        static const char8_t* ru {u8"# Временные ключи. Адрес туннеля будет меняться после каждого запуска i2pd.\n"
                                    "# Чтобы использовать одинаковый временный адрес на нескольких туннелях,\n"
                                    "# указывайте одинаковое название transient-*\n"};
        return ru;
    }
    default: {
        static const char8_t* en {u8"# Temporary keys. The tunnel address will change after each i2pd startup.\n"
                                    "# To use the same temporary address on multiple tunnels,\n"
                                    "# specify the same transient-* name\n"};
        return en;
    }
    }
}

const char8_t *Notepad::ConfigComment::keys(Lang lang)
{
    switch (lang)
    {
    case Lang::ru: {
        static const char8_t* ru {u8"# Ключи, обеспечивающие постоянный адрес. Если указанный файл не существует,\n"
                                    "# ключи будут созданы при первом запуске. Ключи хранятся в рабочей директории i2pd\n"};
        return ru;
    }
    default: {
        static const char8_t* en {u8"# Keys that provide a permanent address. If the specified file does not exist,\n"
                                    "# keys will be created at the first startup. Keys are stored in the i2pd working directory\n"};
        return en;
    }
    }
}

const char8_t *Notepad::ConfigComment::footer(Lang lang, bool isBlinded)
{
    switch (lang)
    {
    case Lang::ru: {
        if (isBlinded)
        {
            static const char8_t* ru {u8"\n"
                                       "# Для создания туннеля нужно вставить этот текст в начало конфига tunnels.conf,\n"
                                       "# который находится в рабочей директории i2pd. Расположение рабочей директории\n"
                                       "# в системе отображается на главной странице веб-консоли i2pd (http://127.0.0.1:7070).\n"
                                       "# Адрес созданного туннеля можно найти также через веб-консоль\n"
                                       "# по пути I2P Tunnels -> TUNNEL NAME -> Encrypted B33 address.\n"
                                       "# Другие параметры и более подробное описание приведенных параметров смотрите\n"
                                       "# в документации: https://i2pd.readthedocs.io/en/latest/user-guide/tunnels/"};
            return ru;
        }
        else
        {
            static const char8_t* ru {u8"\n"
                                       "# Для создания туннеля нужно вставить этот текст в начало конфига tunnels.conf,\n"
                                       "# который находится в рабочей директории i2pd. Расположение рабочей директории\n"
                                       "# в системе отображается на главной странице веб-консоли i2pd (http://127.0.0.1:7070).\n"
                                       "# Адрес созданного туннеля можно найти также через веб-консоль, вкладка I2P Tunnels.\n"
                                       "# Другие параметры и более подробное описание приведенных параметров смотрите\n"
                                       "# в документации: https://i2pd.readthedocs.io/en/latest/user-guide/tunnels/"};
            return ru;
        }
    }
    default: {
        if (isBlinded)
        {
            static const char8_t* en {u8"\n"
                                     "# To create a tunnel, you need to paste this text into the beginning of the tunnels.conf config,\n"
                                     "# which is located in the i2pd working directory. Location of the working directory\n"
                                     "# in the system is displayed on the main page of the i2pd web console (http://127.0.0.1:7070).\n"
                                     "# The address of the created tunnel can also be found through the web console\n"
                                     "# on the path I2P Tunnels -> TUNNEL NAME -> Encrypted B33 address.\n"
                                     "# For other parameters and more detailed description of the above parameters see\n"
                                     "# in the documentation: https://i2pd.readthedocs.io/en/latest/user-guide/tunnels/"};
            return en;
        }
        else
        {
            static const char8_t* en {u8"\n"
                                     "# To create a tunnel, you need to paste this text into the beginning of the tunnels.conf config,\n"
                                     "# which is located in the i2pd working directory. Location of the working directory\n"
                                     "# in the system is displayed on the main page of the i2pd web console (http://127.0.0.1:7070).\n"
                                     "# The address of the created tunnel can also be found through the web console, I2P Tunnels tab.\n"
                                     "# For other parameters and more detailed description of the above parameters see\n"
                                     "# in the documentation: https://i2pd.readthedocs.io/en/latest/user-guide/tunnels/"};
            return en;
        }
    }
    }
}

std::string Notepad::langToString(Lang lang)
{
    return lang == Lang::ru ? "ru" : "en";
}

std::string Notepad::langToCode(Lang lang)
{
    switch (lang)
    {
    case Lang::ru:
        return "ru";
    default:
        return "en";
    }
}

Notepad::Lang Notepad::stringToLang(const std::string &string)
{
    return string == "ru" ? Lang::ru : Lang::en;
}

const char8_t *Notepad::tunnelTypeDescription(Lang lang, TunnelType type)
{
    switch (type)
    {
    case TunnelType::TcpClient: {
        switch (lang)
        {
        case Lang::ru: {
            static const char8_t* ru {u8"# Клиентское подключение по протоколу TCP\n"};
            return ru;
        }
        default: {
            static const char8_t* en {u8"# Client connection via TCP protocol\n"};
            return en;
        }
        }
    }
    case TunnelType::TcpServer: {
        switch (lang)
        {
        case Lang::ru: {
            static const char8_t* ru {u8"# Серверный туннель для приема подключений по протоколу TCP\n"};
            return ru;
        }
        default: {
            static const char8_t* en {u8"# Server tunnel to accept TCP connections\n"};
            return en;
        }
        }
    }
    case TunnelType::UdpClient: {
        switch (lang)
        {
        case Lang::ru: {
            static const char8_t* ru {u8"# Клиентское подключение по протоколу UDP\n"};
            return ru;
        }
        default: {
            static const char8_t* en {u8"# Client connection via UDP protocol\n"};
            return en;
        }
        }
    }
    case TunnelType::UdpServer: {
        switch (lang)
        {
        case Lang::ru: {
            static const char8_t* ru {u8"# Серверный туннель для приема подключений по протоколу UDP\n"};
            return ru;
        }
        default: {
            static const char8_t* en {u8"# Server tunnel to accept UDP connections\n"};
            return en;
        }
        }
    }
    case TunnelType::HttpServer: {
        switch (lang)
        {
        case Lang::ru: {
            static const char8_t* ru {u8"# Серверный туннель для приема подключений по протоколу TCP\n"
                                        "# с добавлением специальных заголовков HTTP к каждому запросу\n"
                                        "# для идентификации клиента\n"};
            return ru;
        }
        default: {
            static const char8_t* en {u8"# Server tunnel to accept TCP connections\n"
                                        "# with adding special HTTP headers to each request\n"
                                        "# to identify the client\n"};
            return en;
        }
        }
    }
    case TunnelType::HttpProxy: {
        switch (lang)
        {
        case Lang::ru: {
            static const char8_t* ru {u8"# HTTP-прокси для выхода в сеть I2P\n"};
            return ru;
        }
        default: {
            static const char8_t* en {u8"# HTTP proxy for I2P network access\n"};
            return en;
        }
        }
    }
    case TunnelType::SocksProxy: {
        switch (lang)
        {
        case Lang::ru: {
            static const char8_t* ru {u8"# SOCKS5-прокси для выхода в сеть I2P\n"};
            return ru;
        }
        default: {
            static const char8_t* en {u8"# SOCKS5 proxy for I2P network access\n"};
            return en;
        }
        }
    }
    case TunnelType::IrcServer: {
        switch (lang)
        {
        case Lang::ru: {
            static const char8_t* ru {u8"# Серверный туннель для приема подключений по протоколу TCP\n"
                                        "# с добавлением специального заголовка для отображения I2P-адресов\n"
                                        "# клиентов, которые подключаются к серверу IRC (Internet Relay Chat)\n"};
            return ru;
        }
        default: {
            static const char8_t* en {u8"# Server tunnel to accept TCP connections\n"
                                        "# with addition of a special header for displaying I2P addresses\n"
                                        "# of clients that connect to the IRC (Internet Relay Chat) server\n"};
            return en;
        }
        }
    }
    default: {
        switch (lang)
        {
        case Lang::ru: {
            static const char8_t* ru {u8"# ^-^ это баг\n"};
            return ru;
        }
        default: {
            static const char8_t* en {u8"# ^-^ this is a bug\n"};
            return en;
        }
        }
    }
    }
}

const char8_t *Notepad::SetterError::name(Lang lang)
{
    switch (lang)
    {
    case Lang::ru: {
        static const char8_t* ru {u8"Имя может содержать только латиницу, цифры, а также символы - _ ."};
        return ru;
    }
    default: {
        static const char8_t* en {u8"The name can contain only Latin characters, digits, and symbols - _ ."};
        return en;
    }
    }
}

const char8_t *Notepad::SetterError::length(Lang lang)
{
    switch (lang)
    {
    case Lang::ru: {
        static const char8_t* ru {u8"Максимальная длина туннеля составляет 8 транзитных узлов (минимальная - 0)"};
        return ru;
    }
    default: {
        static const char8_t* en {u8"The maximum length of the tunnel is 8 transit nodes (minimum is 0)"};
        return en;
    }
    }
}

const char8_t *Notepad::SetterError::variance(Lang lang)
{
    switch (lang)
    {
    case Lang::ru: {
        static const char8_t* ru {u8"Фактор случайного изменения длины нитей может принимать значения от -3 до 3."};
        return ru;
    }
    default: {
        static const char8_t* en {u8"The factor of random variation in strands length can take values from -3 to 3."};
        return en;
    }
    }
}

const char8_t *Notepad::SetterError::quantity(Lang lang)
{
    switch (lang)
    {
    case Lang::ru: {
        static const char8_t* ru {u8"Максимальная ширина туннеля (количество нитей) - 16. Минимальное - 1."};
        return ru;
    }
    default: {
        static const char8_t* en {u8"Maximum tunnel width (number of strands) - 16. Minimum - 1."};
        return en;
    }
    }
}

const char8_t * Notepad::WebUi::tagline(Lang lang)
{
    switch (lang)
    {
    case Lang::ru: {
        static const char8_t* ru {u8"Конструктор конфигов туннелей I2P"};
        return ru;
    }
    default: {
        static const char8_t* en {u8"I2P tunnel config builder"};
        return en;
    }
    }
}

const char8_t * Notepad::WebUi::error(Lang lang)
{
    switch (lang)
    {
    case Lang::ru: {
        static const char8_t* ru {u8"Ошибка"};
        return ru;
    }
    default: {
        static const char8_t* en {u8"Error"};
        return en;
    }
    }
}

const char8_t *Notepad::WebUi::mainThOption(Lang lang)
{
    switch (lang)
    {
    case Lang::ru: {
        static const char8_t* ru {u8"Параметр"};
        return ru;
    }
    default: {
        static const char8_t* en {u8"Parameter"};
        return en;
    }
    }
}

const char8_t *Notepad::WebUi::mainThInput(Lang lang)
{
    switch (lang)
    {
    case Lang::ru: {
        static const char8_t* ru {u8"Значение"};
        return ru;
    }
    default: {
        static const char8_t* en {u8"Value"};
        return en;
    }
    }
}

const char8_t *Notepad::WebUi::mainTunnelName(Lang lang)
{
    switch (lang)
    {
    case Lang::ru: {
        static const char8_t* ru {u8"Название туннеля"};
        return ru;
    }
    default: {
        static const char8_t* en {u8"Tunnel name"};
        return en;
    }
    }
}

const char8_t *Notepad::WebUi::mainTunnelNamePlaceholder(Lang lang)
{
    switch (lang)
    {
    case Lang::ru: {
        static const char8_t* ru {u8"Латиница, цифры и _ - ."};
        return ru;
    }
    default: {
        static const char8_t* en {u8"Letters, numbers, and _ - ."};
        return en;
    }
    }
}

const char8_t *Notepad::WebUi::mainTunnelType(Lang lang)
{
    switch (lang)
    {
    case Lang::ru: {
        static const char8_t* ru {u8"Тип туннеля"};
        return ru;
    }
    default: {
        static const char8_t* en {u8"Tunnel type"};
        return en;
    }
    }
}

const char8_t *Notepad::WebUi::mainDropdownClientTCP(Lang lang)
{
    switch (lang)
    {
    case Lang::ru: {
        static const char8_t* ru {u8"Клиент TCP"};
        return ru;
    }
    default: {
        static const char8_t* en {u8"TCP client"};
        return en;
    }
    }
}

const char8_t *Notepad::WebUi::mainDropdownClientUDP(Lang lang)
{
    switch (lang)
    {
    case Lang::ru: {
        static const char8_t* ru {u8"Клиент UDP"};
        return ru;
    }
    default: {
        static const char8_t* en {u8"UDP client"};
        return en;
    }
    }
}

const char8_t *Notepad::WebUi::mainDropdownServerTCP(Lang lang)
{
    switch (lang)
    {
    case Lang::ru: {
        static const char8_t* ru {u8"Сервер TCP"};
        return ru;
    }
    default: {
        static const char8_t* en {u8"TCP server"};
        return en;
    }
    }
}

const char8_t *Notepad::WebUi::mainDropdownServerUDP(Lang lang)
{
    switch (lang)
    {
    case Lang::ru: {
        static const char8_t* ru {u8"Сервер UDP"};
        return ru;
    }
    default: {
        static const char8_t* en {u8"UDP server"};
        return en;
    }
    }
}

const char8_t *Notepad::WebUi::mainDropdownServerHTTP(Lang lang)
{
    switch (lang)
    {
    case Lang::ru: {
        static const char8_t* ru {u8"Сервер HTTP"};
        return ru;
    }
    default: {
        static const char8_t* en {u8"HTTP server"};
        return en;
    }
    }
}

const char8_t *Notepad::WebUi::mainDropdownServerIRC(Lang lang)
{
    switch (lang)
    {
    case Lang::ru: {
        static const char8_t* ru {u8"Сервер IRC"};
        return ru;
    }
    default: {
        static const char8_t* en {u8"IRC server"};
        return en;
    }
    }
}

const char8_t *Notepad::WebUi::mainDropdownSOCKSProxy(Lang lang)
{
    switch (lang)
    {
    case Lang::ru: {
        static const char8_t* ru {u8"SOCKS5-прокси"};
        return ru;
    }
    default: {
        static const char8_t* en {u8"SOCKS5 proxy"};
        return en;
    }
    }
}

const char8_t *Notepad::WebUi::mainDropdownHTTPProxy(Lang lang)
{
    switch (lang)
    {
    case Lang::ru: {
        static const char8_t* ru {u8"HTTP-прокси"};
        return ru;
    }
    default: {
        static const char8_t* en {u8"HTTP proxy"};
        return en;
    }
    }
}

const char8_t *Notepad::WebUi::mainInbound(Lang lang)
{
    switch (lang)
    {
    case Lang::ru: {
        static const char8_t* ru {u8"Входящие"};
        return ru;
    }
    default: {
        static const char8_t* en {u8"Inbound"};
        return en;
    }
    }
}

const char8_t *Notepad::WebUi::mainOutbound(Lang lang)
{
    switch (lang)
    {
    case Lang::ru: {
        static const char8_t* ru {u8"Исходящие"};
        return ru;
    }
    default: {
        static const char8_t* en {u8"Outbound"};
        return en;
    }
    }
}

const char8_t *Notepad::WebUi::mainLength(Lang lang)
{
    switch (lang)
    {
    case Lang::ru: {
        static const char8_t* ru {u8"Длина нитей (количество транзитных узлов)"};
        return ru;
    }
    default: {
        static const char8_t* en {u8"Thread length (number of transit nodes)"};
        return en;
    }
    }
}

const char8_t *Notepad::WebUi::mainQuantity(Lang lang)
{
    switch (lang)
    {
    case Lang::ru: {
        static const char8_t* ru {u8"Количество нитей (ширина туннеля)"};
        return ru;
    }
    default: {
        static const char8_t* en {u8"Number of strands (tunnel width)"};
        return en;
    }
    }
}

const char8_t *Notepad::WebUi::mainVariance(Lang lang)
{
    switch (lang)
    {
    case Lang::ru: {
        static const char8_t* ru {u8"Число для изменения длины случайных нитей"};
        return ru;
    }
    default: {
        static const char8_t* en {u8"Number to change the length of random strands"};
        return en;
    }
    }
}

const char8_t *Notepad::WebUi::mainB33(Lang lang)
{
    switch (lang)
    {
    case Lang::ru: {
        static const char8_t* ru {u8"Зашифрованный лизсет (защита от пассивного обнаружения ресурса, только для серверов)"};
        return ru;
    }
    default: {
        static const char8_t* en {u8"Encrypted leaseset (protection against passive resource discovery, for servers only)"};
        return en;
    }
    }
}

const char8_t *Notepad::WebUi::mainTransient(Lang lang)
{
    switch (lang)
    {
    case Lang::ru: {
        static const char8_t* ru {u8"Временные ключи (внутрисетевой адрес изменится после рестарта i2pd)"};
        return ru;
    }
    default: {
        static const char8_t* en {u8"Temporary keys (on-net address will change after i2pd restart)"};
        return en;
    }
    }
}

const char8_t *Notepad::WebUi::mainKeepalive(Lang lang)
{
    switch (lang)
    {
    case Lang::ru: {
        static const char8_t* ru {u8"Пинг сервера для поддержания соединения (интервал в секундах; чтобы выключить - 0). Только для клиентских туннелей"};
        return ru;
    }
    default: {
        static const char8_t* en {u8"Server ping to keep the connection alive (interval in seconds; to turn off - 0). For client tunnels only"};
        return en;
    }
    }
}

const char8_t *Notepad::WebUi::mainComments(Lang lang)
{
    switch (lang)
    {
    case Lang::ru: {
        static const char8_t* ru {u8"Добавить подробные комментарии в конфиг"};
        return ru;
    }
    default: {
        static const char8_t* en {u8"Add detailed comments to the config"};
        return en;
    }
    }
}

const char8_t *Notepad::WebUi::mainGenerate(Lang lang)
{
    switch (lang)
    {
    case Lang::ru: {
        static const char8_t* ru {u8"Сгенерировать"};
        return ru;
    }
    default: {
        static const char8_t* en {u8"Generate"};
        return en;
    }
    }
}

const char8_t *Notepad::WebUi::configGoBack(Lang lang)
{
    switch (lang)
    {
    case Lang::ru: {
        static const char8_t* ru {u8"На главную"};
        return ru;
    }
    default: {
        static const char8_t* en {u8"Main page"};
        return en;
    }
    }
}
